package com.tal.pad.javabase.spider;

import java.io.File;
import java.util.*;
import java.util.regex.Pattern;

public class VersionDirectorySorter {
    // 用于匹配版本号格式（x.x.x，每个部分为数字）
//    private static final Pattern VERSION_PATTERN = Pattern.compile("^(v?)\\d+\\.\\d+\\.\\\\d+([\\-_]\\d+)?$");
    
    public static void main(String[] args) {
        // 示例目录，可根据实际情况修改
        String rootDirPath = "./downloads";

//       ========
//        File rootDir = new File(rootDirPath);
//
//        if (!rootDir.exists() || !rootDir.isDirectory()) {
//            System.out.println("目录不存在或不是有效目录: " + rootDirPath);
//            return;
//        }
//
//        // 收集符合条件的版本目录
//        List<File> versionDirs = new ArrayList<>();
//        collectVersionDirectories(rootDir, versionDirs);
//        for (File dir : versionDirs) {
//            System.out.println("-- "+dir.getAbsolutePath());
//        }
//
//        HashMap<File, List<File>> versionMap = new HashMap<>(versionDirs.size());
//        for (File file : versionDirs) {
//            List<File> subList = versionMap.get(file.getParentFile());
//            if(subList!=null){
//                versionMap.put(file.getParentFile(),subList);
//            }else{
//                subList = new LinkedList<File>();
//                versionMap.put(file.getParentFile(), subList);
//            }
//            subList.add(file);
//        }
//        Set<Map.Entry<File, List<File>>> entries = versionMap.entrySet();
//        for(Map.Entry<File, List<File>> entry : entries){
//            System.out.println("filepath: "+entry.getKey().getAbsolutePath());
//
//            Collections.sort(entry.getValue(), new VersionComparator().reversed());
//            for(File file : entry.getValue()){
//                System.out.println("filepath--> : "+file.getAbsolutePath());
//            }
//
//            List<File> fileList = entry.getValue();
//            if(fileList.size()>0){
//                List<File> willDeleteList = fileList.subList( Math.min(fileList.size(), 2), fileList.size() );
//                for(File deleteItem : willDeleteList){
//                    System.out.println("filepath del--> : "+deleteItem.getAbsolutePath());
//                     for(File delItem: Objects.requireNonNull(deleteItem.listFiles())){
//                         if(delItem.exists()){
//                             delItem.delete();
//                         }
//                     }
//                }
//            }
//        }
//
//
//        // 按版本号倒序排序
////        Collections.sort(versionDirs, new VersionComparator().reversed());
//
//        // 打印结果
//        System.out.println("按版本号倒序排列的目录:");
//        for (File dir : versionDirs) {
//            System.out.println(dir.getAbsolutePath());
//        }
//
//        ======

        clearEmptyDir(rootDirPath);
    }


    public static void clearEmptyDir(String directoryPath) {
        // 示例目录路径
        File rootDir = new File(directoryPath);

        // 检查目录是否存在
        if (!rootDir.exists() || !rootDir.isDirectory()) {
            System.out.println("指定的目录不存在或不是一个有效的目录: " + directoryPath);
            return;
        }

        // 递归删除空目录
        boolean isRootEmpty = deleteEmptyDirectories(rootDir);

        // 检查根目录是否也为空并删除
        if (isRootEmpty) {
            if (rootDir.delete()) {
                System.out.println("根目录为空，已删除: " + rootDir.getAbsolutePath());
            } else {
                System.out.println("根目录为空，但删除失败: " + rootDir.getAbsolutePath());
            }
        }

        System.out.println("处理完成");
    }

    /**
     * 递归删除空目录
     * @param dir 要检查的目录
     * @return 如果目录为空且已被删除则返回true，否则返回false
     */
    private static boolean deleteEmptyDirectories(File dir) {
        // 如果不是目录，直接返回false
        if (!dir.isDirectory()) {
            return false;
        }

        // 获取目录下的所有文件和子目录
        File[] files = dir.listFiles();

        // 如果目录为空，直接返回true表示可以删除
        if (files == null || files.length == 0) {
            return true;
        }

        // 标记当前目录是否为空
        boolean isEmpty = true;

        // 递归处理所有子目录
        for (File file : files) {
            // 如果是目录，递归处理
            if (file.isDirectory()) {
                // 如果子目录为空且已被删除，继续检查下一个
                if (deleteEmptyDirectories(file)) {
                    if (file.delete()) {
                        System.out.println("已删除空目录: " + file.getAbsolutePath());
                    } else {
                        System.out.println("删除空目录失败: " + file.getAbsolutePath());
                        isEmpty = false;
                    }
                } else {
                    // 子目录不为空，当前目录也不为空
                    isEmpty = false;
                }
            } else {
                // 存在文件，目录不为空
                isEmpty = false;
            }
        }

        return isEmpty;
    }


    
    /**
     * 递归收集符合条件的版本目录
     * 条件：目录名符合版本格式，且目录下包含文件（不是子目录）
     */
    private static void collectVersionDirectories(File currentDir, List<File> result) {
        File[] files = currentDir.listFiles();
        if (files == null) {
            return;
        }
        
        boolean hasSubdirectories = false;
        boolean hasFiles = false;
        
        for (File file : files) {
            if (file.isDirectory()) {
                hasSubdirectories = true;
                // 递归处理子目录
                collectVersionDirectories(file, result);
            } else {
                hasFiles = true;
            }
        }
        
        // 如果当前目录是最后一层（没有子目录但有文件）且目录名符合版本格式
        if (!hasSubdirectories && hasFiles && isVersionDirectory(currentDir)) {
            result.add(currentDir);
        }
    }
    
    /**
     * 判断目录名是否符合版本号格式
     */
    private static boolean isVersionDirectory(File dir) {
        return true;
//        return VERSION_PATTERN.matcher(dir.getName()).matches();
    }
    
    /**
     * 版本号比较器，用于按版本号升序排序
     */
    static class VersionComparator implements Comparator<File> {
        @Override
        public int compare(File dir1, File dir2) {
            String version1 = dir1.getName();
            String version2 = dir2.getName();
            
            return compareVersionStrings(version1, version2);
        }

        /**
         * 比较两个版本号字符串
         */
        private int compareVersionStrings(String v1, String v2) {
            // 移除可能的前缀"v"
            v1 = v1.startsWith("v") ? v1.substring(1) : v1;
            v2 = v2.startsWith("v") ? v2.substring(1) : v2;

            // 分割主版本号和构建号
            String[] v1Parts = splitVersionAndBuild(v1);
            String[] v2Parts = splitVersionAndBuild(v2);

            // 比较主版本号
            int mainVersionCompare = compareMainVersions(v1Parts[0], v2Parts[0]);
            if (mainVersionCompare != 0) {
                return mainVersionCompare;
            }

            // 如果主版本号相同，比较构建号
            return compareBuildNumbers(v1Parts[1], v2Parts[1]);
        }

        /**
         * 分割版本号为主要版本和构建号
         */
        private String[] splitVersionAndBuild(String version) {
            String mainVersion = version;
            String buildNumber = "0";

            int dashIndex = version.indexOf('-');
            int underscoreIndex = version.indexOf('_');

            int splitIndex = -1;
            if (dashIndex != -1 && underscoreIndex != -1) {
                splitIndex = Math.min(dashIndex, underscoreIndex);
            } else if (dashIndex != -1) {
                splitIndex = dashIndex;
            } else if (underscoreIndex != -1) {
                splitIndex = underscoreIndex;
            }

            if (splitIndex != -1) {
                mainVersion = version.substring(0, splitIndex);
                buildNumber = version.substring(splitIndex + 1);
            }

            return new String[]{mainVersion, buildNumber};
        }

        /**
         * 比较主版本号（x.y.z格式）
         */
        private int compareMainVersions(String v1, String v2) {
            String[] v1Numbers = v1.split("\\.");
            String[] v2Numbers = v2.split("\\.");

            int maxLength = Math.max(v1Numbers.length, v2Numbers.length);

            for (int i = 0; i < maxLength; i++) {
                long num1 = i < v1Numbers.length ? parseIntSafely(v1Numbers[i]) : 0;
                long num2 = i < v2Numbers.length ? parseIntSafely(v2Numbers[i]) : 0;

                if (num1 != num2) {
                    return Long.compare(num1, num2);
                }
            }

            return 0;
        }

        /**
         * 比较构建号
         */
        private int compareBuildNumbers(String b1, String b2) {
            return Long.compare(parseIntSafely(b1), parseIntSafely(b2));
        }

        /**
         * 安全地将字符串转换为整数
         */
        private long parseIntSafely(String s) {
            try {
                return Long.parseLong(s);
            } catch (NumberFormatException e) {
                return 0;
            }
        }
    }
}
    